package com.xqb.modules.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.xqb.common.utils.DateUtils;
import com.xqb.common.utils.SecurityUtils;
import com.xqb.modules.domain.po.LesCourseCatalogue;
import com.xqb.modules.domain.po.StdInteractionQuestion;
import com.xqb.modules.domain.vo.InteractionQuestionVo;
import com.xqb.modules.mapper.LesCourseCatalogueMapper;
import com.xqb.modules.mapper.StdInteractionQuestionMapper;
import com.xqb.modules.service.IStdInteractionQuestionService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

/**
 * 互动提问的问题Service业务层处理
 *
 * @author xqb
 * @date 2024-10-14
 */
@Service
public class StdInteractionQuestionServiceImpl implements IStdInteractionQuestionService {
    @Autowired
    private StdInteractionQuestionMapper stdInteractionQuestionMapper;
    @Autowired
    private LesCourseCatalogueMapper lesCourseCatalogueMapper;

    /**
     * 查询互动提问的问题
     *
     * @param id 互动提问的问题主键
     * @return 互动提问的问题
     */
    @Override
    public StdInteractionQuestion selectStdInteractionQuestionById(Long id) {
        return stdInteractionQuestionMapper.selectStdInteractionQuestionById(id);
    }

    /**
     * 查询互动提问的问题列表
     * 
     * @param stdInteractionQuestion 互动提问的问题
     * @return 互动提问的问题
     */
    @Override
    public List<StdInteractionQuestion> selectStdInteractionQuestionList(StdInteractionQuestion stdInteractionQuestion)
    {
        return stdInteractionQuestionMapper.selectStdInteractionQuestionList(stdInteractionQuestion);
    }

    /**
     * 新增互动提问的问题
     * 
     * @param stdInteractionQuestion 互动提问的问题
     * @return 结果
     */
    @Override
    public int insertStdInteractionQuestion(StdInteractionQuestion stdInteractionQuestion)
    {
        stdInteractionQuestion.setCreateTime(DateUtils.getNowDate());
        if(stdInteractionQuestion.getUserId()==null){
            stdInteractionQuestion.setUserId(SecurityUtils.getUserId());
        }
        return stdInteractionQuestionMapper.insertStdInteractionQuestion(stdInteractionQuestion);
    }

    /**
     * 修改互动提问的问题
     * 
     * @param stdInteractionQuestion 互动提问的问题
     * @return 结果
     */
    @Override
    public int updateStdInteractionQuestion(StdInteractionQuestion stdInteractionQuestion)
    {
        stdInteractionQuestion.setUpdateTime(DateUtils.getNowDate());
        return stdInteractionQuestionMapper.updateStdInteractionQuestion(stdInteractionQuestion);
    }

    /**
     * 批量删除互动提问的问题
     * 
     * @param ids 需要删除的互动提问的问题主键
     * @return 结果
     */
    @Override
    public int deleteStdInteractionQuestionByIds(Long[] ids)
    {
        return stdInteractionQuestionMapper.deleteStdInteractionQuestionByIds(ids);
    }

    /**
     * 删除互动提问的问题信息
     *
     * @param id 互动提问的问题主键
     * @return 结果
     */
    @Override
    public int deleteStdInteractionQuestionById(Long id) {
        return stdInteractionQuestionMapper.deleteStdInteractionQuestionById(id);
    }

    /**
     * 获取互动问题列表
     *
     * @param stdInteractionQuestion 互动提问的问题
     * @param insId                  机构ID
     * @return 互动问题列表
     */
    @Override
    public List<InteractionQuestionVo> getStdInteractionQuestionList(StdInteractionQuestion stdInteractionQuestion, Long insId) {
        // 调用mapper方法获取互动问题列表
        List<InteractionQuestionVo> interactionQuestionVos = stdInteractionQuestionMapper.getStdInteractionQuestionList(stdInteractionQuestion, insId);

        // 判断获取到的互动问题列表是否为空
        if (interactionQuestionVos == null || interactionQuestionVos.isEmpty()) {
            // 如果为空，则返回空列表
            return Collections.emptyList();
        }

        // 从互动问题列表中提取章节ID集合
        List<Long> chapterIds = interactionQuestionVos.stream()
                .map(InteractionQuestionVo::getChapterId)
                .collect(Collectors.toList());

        // 从互动问题列表中提取小节ID集合
        List<Long> sectionIds = interactionQuestionVos.stream()
                .map(InteractionQuestionVo::getSectionId)
                .collect(Collectors.toList());

        // 创建一个集合来存储所有章节和小节ID
        Set<Long> catalogueIds = new HashSet<>(chapterIds);
        // 将小节ID添加到集合中
        catalogueIds.addAll(sectionIds);

        // 创建一个查询条件包装器，用于查询课程目录信息
        LambdaQueryWrapper<LesCourseCatalogue> lesCourseCatalogueLambdaQueryWrapper = new LambdaQueryWrapper<>();
        // 设置查询条件：目录ID在catalogueIds集合中
        lesCourseCatalogueLambdaQueryWrapper.in(LesCourseCatalogue::getId, catalogueIds);
        // 设置查询字段：目录ID和目录名称
        lesCourseCatalogueLambdaQueryWrapper.select(LesCourseCatalogue::getId, LesCourseCatalogue::getName);
        // 执行查询，获取课程目录列表
        List<LesCourseCatalogue> lesCourseCatalogues = lesCourseCatalogueMapper.selectList(lesCourseCatalogueLambdaQueryWrapper);

        // 创建一个映射，用于存储章节ID和章节名称的对应关系
        Map<Long, String> chapterNameMap = lesCourseCatalogues.stream()
                // 过滤出章节ID在chapterIds集合中的目录项
                .filter(catalogue -> chapterIds.contains(catalogue.getId()))
                // 将目录ID和目录名称映射起来
                .collect(Collectors.toMap(LesCourseCatalogue::getId, LesCourseCatalogue::getName));

        // 创建一个映射，用于存储小节ID和小节名称的对应关系
        Map<Long, String> sectionNameMap = lesCourseCatalogues.stream()
                // 过滤出小节ID在sectionIds集合中的目录项
                .filter(catalogue -> sectionIds.contains(catalogue.getId()))
                // 将目录ID和目录名称映射起来
                .collect(Collectors.toMap(LesCourseCatalogue::getId, LesCourseCatalogue::getName));

        // 遍历互动问题列表，为每个问题设置章节名称和小节名称
        interactionQuestionVos.forEach(interactionQuestionVo -> {
            // 设置章节名称，如果不存在则设置为null
            interactionQuestionVo.setChapterName(chapterNameMap.getOrDefault(interactionQuestionVo.getChapterId(), null));
            // 设置小节名称，如果不存在则设置为null
            interactionQuestionVo.setSectionName(sectionNameMap.getOrDefault(interactionQuestionVo.getSectionId(), null));
        });

        // 返回设置好的互动问题列表
        return interactionQuestionVos;
    }

}
